home *** CD-ROM | disk | FTP | other *** search
/ Erotic Games: Memory / Erotic Games: Memory.iso / mac / air_installers / AdobeAIR.exe / setup.swf / scripts / mx / managers / ToolTipManagerImpl.as < prev   
Text File  |  2009-02-12  |  22KB  |  691 lines
  1. package mx.managers
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.events.Event;
  5.    import flash.events.EventDispatcher;
  6.    import flash.events.MouseEvent;
  7.    import flash.events.TimerEvent;
  8.    import flash.geom.Point;
  9.    import flash.geom.Rectangle;
  10.    import flash.utils.Timer;
  11.    import mx.controls.ToolTip;
  12.    import mx.core.ApplicationGlobals;
  13.    import mx.core.IInvalidating;
  14.    import mx.core.IToolTip;
  15.    import mx.core.IUIComponent;
  16.    import mx.core.mx_internal;
  17.    import mx.effects.EffectManager;
  18.    import mx.effects.IAbstractEffect;
  19.    import mx.events.EffectEvent;
  20.    import mx.events.ToolTipEvent;
  21.    import mx.styles.IStyleClient;
  22.    import mx.validators.IValidatorListener;
  23.    
  24.    use namespace mx_internal;
  25.    
  26.    public class ToolTipManagerImpl extends EventDispatcher implements IToolTipManager2
  27.    {
  28.       
  29.       mx_internal static const VERSION:String = "3.0.0.0";
  30.       
  31.       private static var instance:IToolTipManager2;
  32.        
  33.       
  34.       private var _enabled:Boolean = true;
  35.       
  36.       mx_internal var isError:Boolean;
  37.       
  38.       private var _showDelay:Number = 500;
  39.       
  40.       private var _hideEffect:IAbstractEffect;
  41.       
  42.       mx_internal var hideTimer:Timer;
  43.       
  44.       private var _scrubDelay:Number = 100;
  45.       
  46.       private var _toolTipClass:Class;
  47.       
  48.       mx_internal var currentText:String;
  49.       
  50.       mx_internal var showTimer:Timer;
  51.       
  52.       private var _currentToolTip:IToolTip;
  53.       
  54.       mx_internal var scrubTimer:Timer;
  55.       
  56.       mx_internal var previousTarget:DisplayObject;
  57.       
  58.       private var _currentTarget:DisplayObject;
  59.       
  60.       private var _showEffect:IAbstractEffect;
  61.       
  62.       mx_internal var initialized:Boolean = false;
  63.       
  64.       private var _hideDelay:Number = 10000;
  65.       
  66.       public function ToolTipManagerImpl()
  67.       {
  68.          _toolTipClass = ToolTip;
  69.          super();
  70.          if(instance)
  71.          {
  72.             throw new Error("Instance already exists.");
  73.          }
  74.       }
  75.       
  76.       public static function getInstance() : IToolTipManager2
  77.       {
  78.          if(!instance)
  79.          {
  80.             instance = new ToolTipManagerImpl();
  81.          }
  82.          return instance;
  83.       }
  84.       
  85.       mx_internal function systemManager_mouseDownHandler(param1:MouseEvent) : void
  86.       {
  87.          reset();
  88.       }
  89.       
  90.       public function set showDelay(param1:Number) : void
  91.       {
  92.          _showDelay = param1;
  93.       }
  94.       
  95.       mx_internal function hideEffectEnded() : void
  96.       {
  97.          var _loc1_:ToolTipEvent = null;
  98.          reset();
  99.          if(mx_internal::previousTarget)
  100.          {
  101.             _loc1_ = new ToolTipEvent(ToolTipEvent.TOOL_TIP_END);
  102.             _loc1_.toolTip = currentToolTip;
  103.             mx_internal::previousTarget.dispatchEvent(_loc1_);
  104.          }
  105.       }
  106.       
  107.       public function set scrubDelay(param1:Number) : void
  108.       {
  109.          _scrubDelay = param1;
  110.       }
  111.       
  112.       public function get currentToolTip() : IToolTip
  113.       {
  114.          return _currentToolTip;
  115.       }
  116.       
  117.       private function mouseIsOver(param1:DisplayObject) : Boolean
  118.       {
  119.          if(!param1 || !param1.stage)
  120.          {
  121.             return false;
  122.          }
  123.          if(param1.stage.mouseX == 0 && param1.stage.mouseY == 0)
  124.          {
  125.             return false;
  126.          }
  127.          return param1.hitTestPoint(param1.stage.mouseX,param1.stage.mouseY,true);
  128.       }
  129.       
  130.       mx_internal function toolTipMouseOutHandler(param1:MouseEvent) : void
  131.       {
  132.          checkIfTargetChanged(param1.relatedObject);
  133.       }
  134.       
  135.       public function get enabled() : Boolean
  136.       {
  137.          return _enabled;
  138.       }
  139.       
  140.       public function createToolTip(param1:String, param2:Number, param3:Number, param4:String = null, param5:IUIComponent = null) : IToolTip
  141.       {
  142.          var _loc6_:ToolTip = new ToolTip();
  143.          var _loc7_:ISystemManager;
  144.          (_loc7_ = !!param5 ? param5.systemManager : ApplicationGlobals.application.systemManager).toolTipChildren.addChild(_loc6_);
  145.          if(param4)
  146.          {
  147.             _loc6_.setStyle("styleName","errorTip");
  148.             _loc6_.setStyle("borderStyle",param4);
  149.          }
  150.          _loc6_.text = param1;
  151.          sizeTip(_loc6_);
  152.          _loc6_.move(param2,param3);
  153.          return _loc6_ as IToolTip;
  154.       }
  155.       
  156.       mx_internal function reset() : void
  157.       {
  158.          var _loc1_:ISystemManager = null;
  159.          mx_internal::showTimer.reset();
  160.          mx_internal::hideTimer.reset();
  161.          if(currentToolTip)
  162.          {
  163.             if(showEffect || hideEffect)
  164.             {
  165.                currentToolTip.removeEventListener(EffectEvent.EFFECT_END,mx_internal::effectEndHandler);
  166.             }
  167.             EffectManager.endEffectsForTarget(currentToolTip);
  168.             _loc1_ = currentToolTip.systemManager;
  169.             _loc1_.toolTipChildren.removeChild(DisplayObject(currentToolTip));
  170.             currentToolTip = null;
  171.             mx_internal::scrubTimer.delay = scrubDelay;
  172.             mx_internal::scrubTimer.reset();
  173.             if(scrubDelay > 0)
  174.             {
  175.                mx_internal::scrubTimer.delay = scrubDelay;
  176.                mx_internal::scrubTimer.start();
  177.             }
  178.          }
  179.       }
  180.       
  181.       public function get toolTipClass() : Class
  182.       {
  183.          return _toolTipClass;
  184.       }
  185.       
  186.       public function set currentToolTip(param1:IToolTip) : void
  187.       {
  188.          _currentToolTip = param1;
  189.       }
  190.       
  191.       private function hideImmediately(param1:DisplayObject) : void
  192.       {
  193.          checkIfTargetChanged(null);
  194.       }
  195.       
  196.       mx_internal function showTip() : void
  197.       {
  198.          var _loc2_:ISystemManager = null;
  199.          var _loc1_:ToolTipEvent = new ToolTipEvent(ToolTipEvent.TOOL_TIP_SHOW);
  200.          _loc1_.toolTip = currentToolTip;
  201.          currentTarget.dispatchEvent(_loc1_);
  202.          if(mx_internal::isError)
  203.          {
  204.             currentTarget.addEventListener("change",mx_internal::changeHandler);
  205.          }
  206.          else
  207.          {
  208.             _loc2_ = getSystemManager(currentTarget);
  209.             _loc2_.addEventListener(MouseEvent.MOUSE_DOWN,mx_internal::systemManager_mouseDownHandler);
  210.          }
  211.          currentToolTip.visible = true;
  212.          if(!showEffect)
  213.          {
  214.             showEffectEnded();
  215.          }
  216.       }
  217.       
  218.       mx_internal function effectEndHandler(param1:EffectEvent) : void
  219.       {
  220.          if(param1.effectInstance.effect == showEffect)
  221.          {
  222.             showEffectEnded();
  223.          }
  224.          else if(param1.effectInstance.effect == hideEffect)
  225.          {
  226.             hideEffectEnded();
  227.          }
  228.       }
  229.       
  230.       public function get hideDelay() : Number
  231.       {
  232.          return _hideDelay;
  233.       }
  234.       
  235.       public function get currentTarget() : DisplayObject
  236.       {
  237.          return _currentTarget;
  238.       }
  239.       
  240.       mx_internal function showEffectEnded() : void
  241.       {
  242.          var _loc1_:ToolTipEvent = null;
  243.          if(hideDelay == 0)
  244.          {
  245.             hideTip();
  246.          }
  247.          else if(hideDelay < Infinity)
  248.          {
  249.             mx_internal::hideTimer.delay = hideDelay;
  250.             mx_internal::hideTimer.start();
  251.          }
  252.          if(currentTarget)
  253.          {
  254.             _loc1_ = new ToolTipEvent(ToolTipEvent.TOOL_TIP_SHOWN);
  255.             _loc1_.toolTip = currentToolTip;
  256.             currentTarget.dispatchEvent(_loc1_);
  257.          }
  258.       }
  259.       
  260.       public function get hideEffect() : IAbstractEffect
  261.       {
  262.          return _hideEffect;
  263.       }
  264.       
  265.       mx_internal function changeHandler(param1:Event) : void
  266.       {
  267.          reset();
  268.       }
  269.       
  270.       public function set enabled(param1:Boolean) : void
  271.       {
  272.          _enabled = param1;
  273.       }
  274.       
  275.       mx_internal function errorTipMouseOverHandler(param1:MouseEvent) : void
  276.       {
  277.          checkIfTargetChanged(DisplayObject(param1.target));
  278.       }
  279.       
  280.       public function get showDelay() : Number
  281.       {
  282.          return _showDelay;
  283.       }
  284.       
  285.       public function registerErrorString(param1:DisplayObject, param2:String, param3:String) : void
  286.       {
  287.          if(!param2 && param3)
  288.          {
  289.             param1.addEventListener(MouseEvent.MOUSE_OVER,mx_internal::errorTipMouseOverHandler);
  290.             param1.addEventListener(MouseEvent.MOUSE_OUT,mx_internal::errorTipMouseOutHandler);
  291.             if(mouseIsOver(param1))
  292.             {
  293.                showImmediately(param1);
  294.             }
  295.          }
  296.          else if(param2 && !param3)
  297.          {
  298.             param1.removeEventListener(MouseEvent.MOUSE_OVER,mx_internal::errorTipMouseOverHandler);
  299.             param1.removeEventListener(MouseEvent.MOUSE_OUT,mx_internal::errorTipMouseOutHandler);
  300.             if(mouseIsOver(param1))
  301.             {
  302.                hideImmediately(param1);
  303.             }
  304.          }
  305.       }
  306.       
  307.       mx_internal function initialize() : void
  308.       {
  309.          if(!mx_internal::showTimer)
  310.          {
  311.             showTimer = new Timer(0,1);
  312.             mx_internal::showTimer.addEventListener(TimerEvent.TIMER,mx_internal::showTimer_timerHandler);
  313.          }
  314.          if(!mx_internal::hideTimer)
  315.          {
  316.             hideTimer = new Timer(0,1);
  317.             mx_internal::hideTimer.addEventListener(TimerEvent.TIMER,mx_internal::hideTimer_timerHandler);
  318.          }
  319.          if(!mx_internal::scrubTimer)
  320.          {
  321.             scrubTimer = new Timer(0,1);
  322.          }
  323.          initialized = true;
  324.       }
  325.       
  326.       public function destroyToolTip(param1:IToolTip) : void
  327.       {
  328.          var _loc2_:ISystemManager = param1.systemManager;
  329.          _loc2_.toolTipChildren.removeChild(DisplayObject(param1));
  330.       }
  331.       
  332.       public function get scrubDelay() : Number
  333.       {
  334.          return _scrubDelay;
  335.       }
  336.       
  337.       mx_internal function checkIfTargetChanged(param1:DisplayObject) : void
  338.       {
  339.          if(!enabled)
  340.          {
  341.             return;
  342.          }
  343.          findTarget(param1);
  344.          if(currentTarget != mx_internal::previousTarget)
  345.          {
  346.             targetChanged();
  347.             previousTarget = currentTarget;
  348.          }
  349.       }
  350.       
  351.       public function set toolTipClass(param1:Class) : void
  352.       {
  353.          _toolTipClass = param1;
  354.       }
  355.       
  356.       private function getGlobalBounds(param1:DisplayObject) : Rectangle
  357.       {
  358.          var _loc2_:Point = new Point(0,0);
  359.          _loc2_ = param1.localToGlobal(_loc2_);
  360.          return new Rectangle(_loc2_.x,_loc2_.y,param1.width,param1.height);
  361.       }
  362.       
  363.       mx_internal function positionTip() : void
  364.       {
  365.          var _loc1_:Number = NaN;
  366.          var _loc2_:Number = NaN;
  367.          var _loc5_:Rectangle = null;
  368.          var _loc6_:Point = null;
  369.          var _loc7_:IToolTip = null;
  370.          var _loc8_:Number = NaN;
  371.          var _loc9_:Number = NaN;
  372.          var _loc10_:Number = NaN;
  373.          var _loc11_:Number = NaN;
  374.          var _loc3_:Number = currentToolTip.screen.width;
  375.          var _loc4_:Number = currentToolTip.screen.height;
  376.          if(mx_internal::isError)
  377.          {
  378.             _loc1_ = (_loc5_ = getGlobalBounds(currentTarget)).right + 4;
  379.             _loc2_ = _loc5_.top - 1;
  380.             if(_loc1_ + currentToolTip.width > _loc3_)
  381.             {
  382.                _loc8_ = NaN;
  383.                _loc9_ = NaN;
  384.                _loc1_ = _loc5_.left - 2;
  385.                if(_loc1_ + currentToolTip.width + 4 > _loc3_)
  386.                {
  387.                   _loc8_ = _loc3_ - _loc1_ - 4;
  388.                   _loc9_ = Object(toolTipClass).maxWidth;
  389.                   Object(toolTipClass).maxWidth = _loc8_;
  390.                   if(currentToolTip is IStyleClient)
  391.                   {
  392.                      IStyleClient(currentToolTip).setStyle("borderStyle","errorTipAbove");
  393.                   }
  394.                   currentToolTip["text"] = currentToolTip["text"];
  395.                   Object(toolTipClass).maxWidth = _loc9_;
  396.                }
  397.                else
  398.                {
  399.                   if(currentToolTip is IStyleClient)
  400.                   {
  401.                      IStyleClient(currentToolTip).setStyle("borderStyle","errorTipAbove");
  402.                   }
  403.                   currentToolTip["text"] = currentToolTip["text"];
  404.                }
  405.                if(currentToolTip.height + 2 < _loc5_.top)
  406.                {
  407.                   _loc2_ = _loc5_.top - (currentToolTip.height + 2);
  408.                }
  409.                else
  410.                {
  411.                   _loc2_ = _loc5_.bottom + 2;
  412.                   if(!isNaN(_loc8_))
  413.                   {
  414.                      Object(toolTipClass).maxWidth = _loc8_;
  415.                   }
  416.                   if(currentToolTip is IStyleClient)
  417.                   {
  418.                      IStyleClient(currentToolTip).setStyle("borderStyle","errorTipBelow");
  419.                   }
  420.                   currentToolTip["text"] = currentToolTip["text"];
  421.                   if(!isNaN(_loc9_))
  422.                   {
  423.                      Object(toolTipClass).maxWidth = _loc9_;
  424.                   }
  425.                }
  426.             }
  427.             sizeTip(currentToolTip);
  428.             _loc6_ = new Point(_loc1_,_loc2_);
  429.             _loc7_ = currentToolTip;
  430.             _loc1_ = (_loc6_ = DisplayObject(_loc7_).root.globalToLocal(_loc6_)).x;
  431.             _loc2_ = _loc6_.y;
  432.          }
  433.          else
  434.          {
  435.             _loc1_ = ApplicationGlobals.application.mouseX + 11;
  436.             _loc2_ = ApplicationGlobals.application.mouseY + 22;
  437.             _loc10_ = currentToolTip.width;
  438.             if(_loc1_ + _loc10_ > _loc3_)
  439.             {
  440.                _loc1_ = _loc3_ - _loc10_;
  441.             }
  442.             _loc11_ = currentToolTip.height;
  443.             if(_loc2_ + _loc11_ > _loc4_)
  444.             {
  445.                _loc2_ = _loc4_ - _loc11_;
  446.             }
  447.          }
  448.          currentToolTip.move(_loc1_,_loc2_);
  449.       }
  450.       
  451.       mx_internal function errorTipMouseOutHandler(param1:MouseEvent) : void
  452.       {
  453.          checkIfTargetChanged(param1.relatedObject);
  454.       }
  455.       
  456.       mx_internal function findTarget(param1:DisplayObject) : void
  457.       {
  458.          while(param1)
  459.          {
  460.             if(param1 is IValidatorListener)
  461.             {
  462.                currentText = IValidatorListener(param1).errorString;
  463.                if(mx_internal::currentText != null && mx_internal::currentText != "")
  464.                {
  465.                   currentTarget = param1;
  466.                   isError = true;
  467.                   return;
  468.                }
  469.             }
  470.             if(param1 is IToolTipManagerClient)
  471.             {
  472.                currentText = IToolTipManagerClient(param1).toolTip;
  473.                if(mx_internal::currentText != null)
  474.                {
  475.                   currentTarget = param1;
  476.                   isError = false;
  477.                   return;
  478.                }
  479.             }
  480.             param1 = param1.parent;
  481.          }
  482.          currentText = null;
  483.          currentTarget = null;
  484.       }
  485.       
  486.       public function registerToolTip(param1:DisplayObject, param2:String, param3:String) : void
  487.       {
  488.          if(!param2 && param3)
  489.          {
  490.             param1.addEventListener(MouseEvent.MOUSE_OVER,mx_internal::toolTipMouseOverHandler);
  491.             param1.addEventListener(MouseEvent.MOUSE_OUT,mx_internal::toolTipMouseOutHandler);
  492.             if(mouseIsOver(param1))
  493.             {
  494.                showImmediately(param1);
  495.             }
  496.          }
  497.          else if(param2 && !param3)
  498.          {
  499.             param1.removeEventListener(MouseEvent.MOUSE_OVER,mx_internal::toolTipMouseOverHandler);
  500.             param1.removeEventListener(MouseEvent.MOUSE_OUT,mx_internal::toolTipMouseOutHandler);
  501.             if(mouseIsOver(param1))
  502.             {
  503.                hideImmediately(param1);
  504.             }
  505.          }
  506.       }
  507.       
  508.       private function showImmediately(param1:DisplayObject) : void
  509.       {
  510.          var _loc2_:Number = ToolTipManager.showDelay;
  511.          ToolTipManager.showDelay = 0;
  512.          checkIfTargetChanged(param1);
  513.          ToolTipManager.showDelay = _loc2_;
  514.       }
  515.       
  516.       public function set hideDelay(param1:Number) : void
  517.       {
  518.          _hideDelay = param1;
  519.       }
  520.       
  521.       private function getSystemManager(param1:DisplayObject) : ISystemManager
  522.       {
  523.          return param1 is IUIComponent ? IUIComponent(param1).systemManager : null;
  524.       }
  525.       
  526.       public function set currentTarget(param1:DisplayObject) : void
  527.       {
  528.          _currentTarget = param1;
  529.       }
  530.       
  531.       public function sizeTip(param1:IToolTip) : void
  532.       {
  533.          if(param1 is IInvalidating)
  534.          {
  535.             IInvalidating(param1).validateNow();
  536.          }
  537.          param1.setActualSize(param1.getExplicitOrMeasuredWidth(),param1.getExplicitOrMeasuredHeight());
  538.       }
  539.       
  540.       mx_internal function showTimer_timerHandler(param1:TimerEvent) : void
  541.       {
  542.          if(currentTarget)
  543.          {
  544.             createTip();
  545.             initializeTip();
  546.             positionTip();
  547.             showTip();
  548.          }
  549.       }
  550.       
  551.       mx_internal function hideTimer_timerHandler(param1:TimerEvent) : void
  552.       {
  553.          hideTip();
  554.       }
  555.       
  556.       public function set showEffect(param1:IAbstractEffect) : void
  557.       {
  558.          _showEffect = param1 as IAbstractEffect;
  559.       }
  560.       
  561.       public function set hideEffect(param1:IAbstractEffect) : void
  562.       {
  563.          _hideEffect = param1 as IAbstractEffect;
  564.       }
  565.       
  566.       mx_internal function targetChanged() : void
  567.       {
  568.          var _loc1_:ToolTipEvent = null;
  569.          if(!mx_internal::initialized)
  570.          {
  571.             initialize();
  572.          }
  573.          if(mx_internal::previousTarget && currentToolTip)
  574.          {
  575.             _loc1_ = new ToolTipEvent(ToolTipEvent.TOOL_TIP_HIDE);
  576.             _loc1_.toolTip = currentToolTip;
  577.             mx_internal::previousTarget.dispatchEvent(_loc1_);
  578.          }
  579.          reset();
  580.          if(currentTarget)
  581.          {
  582.             if(mx_internal::currentText == "")
  583.             {
  584.                return;
  585.             }
  586.             _loc1_ = new ToolTipEvent(ToolTipEvent.TOOL_TIP_START);
  587.             currentTarget.dispatchEvent(_loc1_);
  588.             if(showDelay == 0 || mx_internal::scrubTimer.running)
  589.             {
  590.                createTip();
  591.                initializeTip();
  592.                positionTip();
  593.                showTip();
  594.             }
  595.             else
  596.             {
  597.                mx_internal::showTimer.delay = showDelay;
  598.                mx_internal::showTimer.start();
  599.             }
  600.          }
  601.       }
  602.       
  603.       mx_internal function initializeTip() : void
  604.       {
  605.          if(currentToolTip is ToolTip)
  606.          {
  607.             ToolTip(currentToolTip).text = mx_internal::currentText;
  608.          }
  609.          if(mx_internal::isError && currentToolTip is IStyleClient)
  610.          {
  611.             IStyleClient(currentToolTip).setStyle("styleName","errorTip");
  612.          }
  613.          sizeTip(currentToolTip);
  614.          if(currentToolTip is IStyleClient)
  615.          {
  616.             if(showEffect)
  617.             {
  618.                IStyleClient(currentToolTip).setStyle("showEffect",showEffect);
  619.             }
  620.             if(hideEffect)
  621.             {
  622.                IStyleClient(currentToolTip).setStyle("hideEffect",hideEffect);
  623.             }
  624.          }
  625.          if(showEffect || hideEffect)
  626.          {
  627.             currentToolTip.addEventListener(EffectEvent.EFFECT_END,mx_internal::effectEndHandler);
  628.          }
  629.       }
  630.       
  631.       public function get showEffect() : IAbstractEffect
  632.       {
  633.          return _showEffect;
  634.       }
  635.       
  636.       mx_internal function toolTipMouseOverHandler(param1:MouseEvent) : void
  637.       {
  638.          checkIfTargetChanged(DisplayObject(param1.target));
  639.       }
  640.       
  641.       mx_internal function hideTip() : void
  642.       {
  643.          var _loc1_:ToolTipEvent = null;
  644.          var _loc2_:ISystemManager = null;
  645.          if(mx_internal::previousTarget)
  646.          {
  647.             _loc1_ = new ToolTipEvent(ToolTipEvent.TOOL_TIP_HIDE);
  648.             _loc1_.toolTip = currentToolTip;
  649.             mx_internal::previousTarget.dispatchEvent(_loc1_);
  650.          }
  651.          if(currentToolTip)
  652.          {
  653.             currentToolTip.visible = false;
  654.          }
  655.          if(mx_internal::isError)
  656.          {
  657.             if(currentTarget)
  658.             {
  659.                currentTarget.removeEventListener("change",mx_internal::changeHandler);
  660.             }
  661.          }
  662.          else if(mx_internal::previousTarget)
  663.          {
  664.             _loc2_ = getSystemManager(mx_internal::previousTarget);
  665.             _loc2_.removeEventListener(MouseEvent.MOUSE_DOWN,mx_internal::systemManager_mouseDownHandler);
  666.          }
  667.          if(!hideEffect)
  668.          {
  669.             hideEffectEnded();
  670.          }
  671.       }
  672.       
  673.       mx_internal function createTip() : void
  674.       {
  675.          var _loc1_:ToolTipEvent = new ToolTipEvent(ToolTipEvent.TOOL_TIP_CREATE);
  676.          currentTarget.dispatchEvent(_loc1_);
  677.          if(_loc1_.toolTip)
  678.          {
  679.             currentToolTip = _loc1_.toolTip;
  680.          }
  681.          else
  682.          {
  683.             currentToolTip = new toolTipClass();
  684.          }
  685.          currentToolTip.visible = false;
  686.          var _loc2_:ISystemManager = getSystemManager(currentTarget);
  687.          _loc2_.toolTipChildren.addChild(DisplayObject(currentToolTip));
  688.       }
  689.    }
  690. }
  691.